const express = require('express');
const router = express.Router();
const CompanyAccount = require('../models/companyAccount');

/**
 * &#128721; 停用指定账户 (设置 is_active = false)
 * URL: PUT /api/accounts/:id/deactivate
 */
router.put('/accounts/:id/deactivate', async (req, res) => {
  try {
    const { id } = req.params;
    const account = await CompanyAccount.findByPk(id);
    
    if (!account) {
      return res.status(404).json({ error: '账户不存在' });
    }
    
    account.is_active = false;
    await account.save();
    res.json({ message: '账户已停用', data: account });
  } catch (error) {
    console.error('&#128269; 更新错误:', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});
// 编辑数据
router.put('/accounts/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { name, account, bank_name, is_active } = req.body;

    // 数据验证
    if (!id) {
      return res.status(400).json({ error: '缺少账户ID' });
    }

    if (!name && !account && !bank_name && is_active === undefined) {
      return res.status(400).json({ error: '没有提供要更新的字段' });
    }

    // 查找账户
    const companyAccount = await CompanyAccount.findByPk(id);
    
    if (!companyAccount) {
      return res.status(404).json({ error: `ID为 ${id} 的账户不存在` });
    }

    // 构建更新对象（只更新提供的字段）
    const updateData = {};
    if (name !== undefined) updateData.name = name;
    if (account !== undefined) updateData.account = account;
    if (bank_name !== undefined) updateData.bank_name = bank_name;
    if (is_active !== undefined) updateData.is_active = is_active;

    // 执行更新
    await companyAccount.update(updateData);

    // 重新加载更新后的数据
    const updatedAccount = await CompanyAccount.findByPk(id);

    res.json({
      success: true,
      message: '账户更新成功',
      code:10000,
      data: updatedAccount
    });

  } catch (error) {
    console.error('❌ 更新错误:', error);
    
    // 数据库验证错误
    if (error.name === 'SequelizeValidationError') {
      const errors = error.errors.map(err => ({
        field: err.path,
        message: err.message
      }));
      return res.status(400).json({
        error: '数据验证失败',
        details: errors
      });
    }

    // 唯一约束错误
    if (error.name === 'SequelizeUniqueConstraintError') {
      return res.status(400).json({
        error: '账号已存在',
        field: 'account'
      });
    }

    res.status(500).json({ 
      error: '服务器内部错误',
      message: process.env.NODE_ENV === 'development' ? error.message : '内部服务器错误'
    });
  }
});

/**
 * &#10133; 新增账户
 * URL: POST /api/accounts
 * Body: { name, account, bank_name }
 */
router.post('/accounts', async (req, res) => {
  try {
    // console.log(req.body)
    const { name, account, bank_name } = req.body;
    
    // &#128221; 基础验证
    if (!name || !account || !bank_name) {
      return res.status(400).json({ error: '缺少必要字段' });
    }
    
    const newAccount = await CompanyAccount.create({
      name,
      account,
      bank_name,
      is_active: true // 默认激活
    });
    
    res.status(201).json({ data:newAccount,code:10000}); // 201 Created
  } catch (error) {
    console.error('&#128269; 创建错误:', error);
    if (error.name === 'SequelizeUniqueConstraintError') {
      return res.status(409).json({ error: '账号已存在' }); // 唯一性冲突
    }
    res.status(500).json({ error: '服务器内部错误' });
  }
});

// 删除指定账号
router.delete('/accounts/:id', async (req, res) => {
  try {
    const { id } = req.params;

    // 验证ID是否存在
    if (!id) {
      return res.status(400).json({
        success: false,
        error: '缺少账户ID参数'
      });
    }

    // 验证ID格式（如果是数字ID）
    if (isNaN(Number(id))) {
      return res.status(400).json({
        success: false,
        error: 'ID格式不正确'
      });
    }

    // 查找要删除的账户
    const companyAccount = await CompanyAccount.findByPk(id);
    
    if (!companyAccount) {
      return res.status(404).json({
        success: false,
        error: `ID为 ${id} 的账户不存在`
      });
    }

    // 保存删除前的数据用于响应
    const deletedAccount = { ...companyAccount.toJSON() };

    // 执行删除操作
    await companyAccount.destroy();

    // 返回成功响应
    res.status(200).json({
      success: true,
      code:10000,
      message: '账户删除成功',
      data: deletedAccount,
      deletedAt: new Date().toISOString()
    });

  } catch (error) {
    console.error('❌ 删除错误:', error);
    
    // 数据库外键约束错误
    if (error.name === 'SequelizeForeignKeyConstraintError') {
      return res.status(409).json({
        success: false,
        error: '无法删除账户，存在关联数据',
        suggestion: '请先删除相关的关联数据'
      });
    }

    res.status(500).json({
      success: false,
      error: '服务器内部错误',
      message: process.env.NODE_ENV === 'development' ? error.message : '内部服务器错误'
    });
  }
});

/**
 * &#128229; 获取所有活跃账户 (is_active = true)
 * URL: GET /api/accounts?active=true
 */
router.get('/accounts', async (req, res) => {
  try {
    const { active = 'true' } = req.query; // 默认查询活跃账户
    const accounts = await CompanyAccount.findAll({
      where: { is_active: active === 'true' },
      order: [['createdAt', 'DESC']] // 按创建时间倒序排列
    });
    res.json(accounts);
  } catch (error) {
    console.error('&#128269; 查询错误:', error);
    res.status(500).json({ error: '服务器内部错误' });
  }
});

module.exports = router